home *** CD-ROM | disk | FTP | other *** search
/ PCGUIA 127 / PC Guia 127.iso / Software / Produtividade / OpenOffice.org 2.0.1 / openofficeorg4.cab / test_tempfile.py < prev    next >
Text File  |  2005-11-19  |  20KB  |  661 lines
  1. # tempfile.py unit tests.
  2.  
  3. import tempfile
  4. import os
  5. import sys
  6. import re
  7. import errno
  8. import warnings
  9.  
  10. import unittest
  11. from test import test_support
  12.  
  13. warnings.filterwarnings("ignore",
  14.                         category=RuntimeWarning,
  15.                         message="mktemp", module=__name__)
  16.  
  17. if hasattr(os, 'stat'):
  18.     import stat
  19.     has_stat = 1
  20. else:
  21.     has_stat = 0
  22.  
  23. has_textmode = (tempfile._text_openflags != tempfile._bin_openflags)
  24. has_spawnl = hasattr(os, 'spawnl')
  25.  
  26. # TEST_FILES may need to be tweaked for systems depending on the maximum
  27. # number of files that can be opened at one time (see ulimit -n)
  28. if sys.platform == 'mac':
  29.     TEST_FILES = 32
  30. else:
  31.     TEST_FILES = 100
  32.  
  33. # This is organized as one test for each chunk of code in tempfile.py,
  34. # in order of their appearance in the file.  Testing which requires
  35. # threads is not done here.
  36.  
  37. # Common functionality.
  38. class TC(unittest.TestCase):
  39.  
  40.     str_check = re.compile(r"[a-zA-Z0-9_-]{6}$")
  41.  
  42.     def failOnException(self, what, ei=None):
  43.         if ei is None:
  44.             ei = sys.exc_info()
  45.         self.fail("%s raised %s: %s" % (what, ei[0], ei[1]))
  46.  
  47.     def nameCheck(self, name, dir, pre, suf):
  48.         (ndir, nbase) = os.path.split(name)
  49.         npre  = nbase[:len(pre)]
  50.         nsuf  = nbase[len(nbase)-len(suf):]
  51.  
  52.         self.assertEqual(ndir, dir,
  53.                          "file '%s' not in directory '%s'" % (name, dir))
  54.         self.assertEqual(npre, pre,
  55.                          "file '%s' does not begin with '%s'" % (nbase, pre))
  56.         self.assertEqual(nsuf, suf,
  57.                          "file '%s' does not end with '%s'" % (nbase, suf))
  58.  
  59.         nbase = nbase[len(pre):len(nbase)-len(suf)]
  60.         self.assert_(self.str_check.match(nbase),
  61.                      "random string '%s' does not match /^[a-zA-Z0-9_-]{6}$/"
  62.                      % nbase)
  63.  
  64. test_classes = []
  65.  
  66. class test_exports(TC):
  67.     def test_exports(self):
  68.         # There are no surprising symbols in the tempfile module
  69.         dict = tempfile.__dict__
  70.  
  71.         expected = {
  72.             "NamedTemporaryFile" : 1,
  73.             "TemporaryFile" : 1,
  74.             "mkstemp" : 1,
  75.             "mkdtemp" : 1,
  76.             "mktemp" : 1,
  77.             "TMP_MAX" : 1,
  78.             "gettempprefix" : 1,
  79.             "gettempdir" : 1,
  80.             "tempdir" : 1,
  81.             "template" : 1
  82.         }
  83.  
  84.         unexp = []
  85.         for key in dict:
  86.             if key[0] != '_' and key not in expected:
  87.                 unexp.append(key)
  88.         self.failUnless(len(unexp) == 0,
  89.                         "unexpected keys: %s" % unexp)
  90.  
  91. test_classes.append(test_exports)
  92.  
  93.  
  94. class test__RandomNameSequence(TC):
  95.     """Test the internal iterator object _RandomNameSequence."""
  96.  
  97.     def setUp(self):
  98.         self.r = tempfile._RandomNameSequence()
  99.  
  100.     def test_get_six_char_str(self):
  101.         # _RandomNameSequence returns a six-character string
  102.         s = self.r.next()
  103.         self.nameCheck(s, '', '', '')
  104.  
  105.     def test_many(self):
  106.         # _RandomNameSequence returns no duplicate strings (stochastic)
  107.  
  108.         dict = {}
  109.         r = self.r
  110.         for i in xrange(TEST_FILES):
  111.             s = r.next()
  112.             self.nameCheck(s, '', '', '')
  113.             self.failIf(s in dict)
  114.             dict[s] = 1
  115.  
  116.     def test_supports_iter(self):
  117.         # _RandomNameSequence supports the iterator protocol
  118.  
  119.         i = 0
  120.         r = self.r
  121.         try:
  122.             for s in r:
  123.                 i += 1
  124.                 if i == 20:
  125.                     break
  126.         except:
  127.             failOnException("iteration")
  128.  
  129. test_classes.append(test__RandomNameSequence)
  130.  
  131.  
  132. class test__candidate_tempdir_list(TC):
  133.     """Test the internal function _candidate_tempdir_list."""
  134.  
  135.     def test_nonempty_list(self):
  136.         # _candidate_tempdir_list returns a nonempty list of strings
  137.  
  138.         cand = tempfile._candidate_tempdir_list()
  139.  
  140.         self.failIf(len(cand) == 0)
  141.         for c in cand:
  142.             self.assert_(isinstance(c, basestring),
  143.                          "%s is not a string" % c)
  144.  
  145.     def test_wanted_dirs(self):
  146.         # _candidate_tempdir_list contains the expected directories
  147.  
  148.         # Make sure the interesting environment variables are all set.
  149.         added = []
  150.         try:
  151.             for envname in 'TMPDIR', 'TEMP', 'TMP':
  152.                 dirname = os.getenv(envname)
  153.                 if not dirname:
  154.                     os.environ[envname] = os.path.abspath(envname)
  155.                     added.append(envname)
  156.  
  157.             cand = tempfile._candidate_tempdir_list()
  158.  
  159.             for envname in 'TMPDIR', 'TEMP', 'TMP':
  160.                 dirname = os.getenv(envname)
  161.                 if not dirname: raise ValueError
  162.                 self.assert_(dirname in cand)
  163.  
  164.             try:
  165.                 dirname = os.getcwd()
  166.             except (AttributeError, os.error):
  167.                 dirname = os.curdir
  168.  
  169.             self.assert_(dirname in cand)
  170.  
  171.             # Not practical to try to verify the presence of OS-specific
  172.             # paths in this list.
  173.         finally:
  174.             for p in added:
  175.                 del os.environ[p]
  176.  
  177. test_classes.append(test__candidate_tempdir_list)
  178.  
  179.  
  180. # We test _get_default_tempdir by testing gettempdir.
  181.  
  182.  
  183. class test__get_candidate_names(TC):
  184.     """Test the internal function _get_candidate_names."""
  185.  
  186.     def test_retval(self):
  187.         # _get_candidate_names returns a _RandomNameSequence object
  188.         obj = tempfile._get_candidate_names()
  189.         self.assert_(isinstance(obj, tempfile._RandomNameSequence))
  190.  
  191.     def test_same_thing(self):
  192.         # _get_candidate_names always returns the same object
  193.         a = tempfile._get_candidate_names()
  194.         b = tempfile._get_candidate_names()
  195.  
  196.         self.assert_(a is b)
  197.  
  198. test_classes.append(test__get_candidate_names)
  199.  
  200.  
  201. class test__mkstemp_inner(TC):
  202.     """Test the internal function _mkstemp_inner."""
  203.  
  204.     class mkstemped:
  205.         _bflags = tempfile._bin_openflags
  206.         _tflags = tempfile._text_openflags
  207.         _close = os.close
  208.         _unlink = os.unlink
  209.  
  210.         def __init__(self, dir, pre, suf, bin):
  211.             if bin: flags = self._bflags
  212.             else:   flags = self._tflags
  213.  
  214.             (self.fd, self.name) = tempfile._mkstemp_inner(dir, pre, suf, flags)
  215.  
  216.         def write(self, str):
  217.             os.write(self.fd, str)
  218.  
  219.         def __del__(self):
  220.             self._close(self.fd)
  221.             self._unlink(self.name)
  222.  
  223.     def do_create(self, dir=None, pre="", suf="", bin=1):
  224.         if dir is None:
  225.             dir = tempfile.gettempdir()
  226.         try:
  227.             file = self.mkstemped(dir, pre, suf, bin)
  228.         except:
  229.             self.failOnException("_mkstemp_inner")
  230.  
  231.         self.nameCheck(file.name, dir, pre, suf)
  232.         return file
  233.  
  234.     def test_basic(self):
  235.         # _mkstemp_inner can create files
  236.         self.do_create().write("blat")
  237.         self.do_create(pre="a").write("blat")
  238.         self.do_create(suf="b").write("blat")
  239.         self.do_create(pre="a", suf="b").write("blat")
  240.         self.do_create(pre="aa", suf=".txt").write("blat")
  241.  
  242.     def test_basic_many(self):
  243.         # _mkstemp_inner can create many files (stochastic)
  244.         extant = range(TEST_FILES)
  245.         for i in extant:
  246.             extant[i] = self.do_create(pre="aa")
  247.  
  248.     def test_choose_directory(self):
  249.         # _mkstemp_inner can create files in a user-selected directory
  250.         dir = tempfile.mkdtemp()
  251.         try:
  252.             self.do_create(dir=dir).write("blat")
  253.         finally:
  254.             os.rmdir(dir)
  255.  
  256.     def test_file_mode(self):
  257.         # _mkstemp_inner creates files with the proper mode
  258.         if not has_stat:
  259.             return            # ugh, can't use TestSkipped.
  260.  
  261.         file = self.do_create()
  262.         mode = stat.S_IMODE(os.stat(file.name).st_mode)
  263.         expected = 0600
  264.         if sys.platform in ('win32', 'os2emx', 'mac'):
  265.             # There's no distinction among 'user', 'group' and 'world';
  266.             # replicate the 'user' bits.
  267.             user = expected >> 6
  268.             expected = user * (1 + 8 + 64)
  269.         self.assertEqual(mode, expected)
  270.  
  271.     def test_noinherit(self):
  272.         # _mkstemp_inner file handles are not inherited by child processes
  273.         if not has_spawnl:
  274.             return            # ugh, can't use TestSkipped.
  275.  
  276.         if test_support.verbose:
  277.             v="v"
  278.         else:
  279.             v="q"
  280.  
  281.         file = self.do_create()
  282.         fd = "%d" % file.fd
  283.  
  284.         try:
  285.             me = __file__
  286.         except NameError:
  287.             me = sys.argv[0]
  288.  
  289.         # We have to exec something, so that FD_CLOEXEC will take
  290.         # effect.  The core of this test is therefore in
  291.         # tf_inherit_check.py, which see.
  292.         tester = os.path.join(os.path.dirname(os.path.abspath(me)),
  293.                               "tf_inherit_check.py")
  294.  
  295.         # On Windows a spawn* /path/ with embedded spaces shouldn't be quoted,
  296.         # but an arg with embedded spaces should be decorated with double
  297.         # quotes on each end
  298.         if sys.platform in ('win32'):
  299.             decorated = '"%s"' % sys.executable
  300.             tester = '"%s"' % tester
  301.         else:
  302.             decorated = sys.executable
  303.  
  304.         retval = os.spawnl(os.P_WAIT, sys.executable, decorated, tester, v, fd)
  305.         self.failIf(retval < 0,
  306.                     "child process caught fatal signal %d" % -retval)
  307.         self.failIf(retval > 0, "child process reports failure")
  308.  
  309.     def test_textmode(self):
  310.         # _mkstemp_inner can create files in text mode
  311.         if not has_textmode:
  312.             return            # ugh, can't use TestSkipped.
  313.  
  314.         self.do_create(bin=0).write("blat\n")
  315.         # XXX should test that the file really is a text file
  316.  
  317. test_classes.append(test__mkstemp_inner)
  318.  
  319.  
  320. class test_gettempprefix(TC):
  321.     """Test gettempprefix()."""
  322.  
  323.     def test_sane_template(self):
  324.         # gettempprefix returns a nonempty prefix string
  325.         p = tempfile.gettempprefix()
  326.  
  327.         self.assert_(isinstance(p, basestring))
  328.         self.assert_(len(p) > 0)
  329.  
  330.     def test_usable_template(self):
  331.         # gettempprefix returns a usable prefix string
  332.  
  333.         # Create a temp directory, avoiding use of the prefix.
  334.         # Then attempt to create a file whose name is
  335.         # prefix + 'xxxxxx.xxx' in that directory.
  336.         p = tempfile.gettempprefix() + "xxxxxx.xxx"
  337.         d = tempfile.mkdtemp(prefix="")
  338.         try:
  339.             p = os.path.join(d, p)
  340.             try:
  341.                 fd = os.open(p, os.O_RDWR | os.O_CREAT)
  342.             except:
  343.                 self.failOnException("os.open")
  344.             os.close(fd)
  345.             os.unlink(p)
  346.         finally:
  347.             os.rmdir(d)
  348.  
  349. test_classes.append(test_gettempprefix)
  350.  
  351.  
  352. class test_gettempdir(TC):
  353.     """Test gettempdir()."""
  354.  
  355.     def test_directory_exists(self):
  356.         # gettempdir returns a directory which exists
  357.  
  358.         dir = tempfile.gettempdir()
  359.         self.assert_(os.path.isabs(dir) or dir == os.curdir,
  360.                      "%s is not an absolute path" % dir)
  361.         self.assert_(os.path.isdir(dir),
  362.                      "%s is not a directory" % dir)
  363.  
  364.     def test_directory_writable(self):
  365.         # gettempdir returns a directory writable by the user
  366.  
  367.         # sneaky: just instantiate a NamedTemporaryFile, which
  368.         # defaults to writing into the directory returned by
  369.         # gettempdir.
  370.         try:
  371.             file = tempfile.NamedTemporaryFile()
  372.             file.write("blat")
  373.             file.close()
  374.         except:
  375.             self.failOnException("create file in %s" % tempfile.gettempdir())
  376.  
  377.     def test_same_thing(self):
  378.         # gettempdir always returns the same object
  379.         a = tempfile.gettempdir()
  380.         b = tempfile.gettempdir()
  381.  
  382.         self.assert_(a is b)
  383.  
  384. test_classes.append(test_gettempdir)
  385.  
  386.  
  387. class test_mkstemp(TC):
  388.     """Test mkstemp()."""
  389.  
  390.     def do_create(self, dir=None, pre="", suf="", ):
  391.         if dir is None:
  392.             dir = tempfile.gettempdir()
  393.         try:
  394.             (fd, name) = tempfile.mkstemp(dir=dir, prefix=pre, suffix=suf)
  395.         except:
  396.             self.failOnException("mkstemp")
  397.  
  398.         try:
  399.             self.nameCheck(name, dir, pre, suf)
  400.         finally:
  401.             os.close(fd)
  402.             os.unlink(name)
  403.  
  404.     def test_basic(self):
  405.         # mkstemp can create files
  406.         self.do_create()
  407.         self.do_create(pre="a")
  408.         self.do_create(suf="b")
  409.         self.do_create(pre="a", suf="b")
  410.         self.do_create(pre="aa", suf=".txt")
  411.  
  412.     def test_choose_directory(self):
  413.         # mkstemp can create directories in a user-selected directory
  414.         dir = tempfile.mkdtemp()
  415.         try:
  416.             self.do_create(dir=dir)
  417.         finally:
  418.             os.rmdir(dir)
  419.  
  420. test_classes.append(test_mkstemp)
  421.  
  422.  
  423. class test_mkdtemp(TC):
  424.     """Test mkdtemp()."""
  425.  
  426.     def do_create(self, dir=None, pre="", suf=""):
  427.         if dir is None:
  428.             dir = tempfile.gettempdir()
  429.         try:
  430.             name = tempfile.mkdtemp(dir=dir, prefix=pre, suffix=suf)
  431.         except:
  432.             self.failOnException("mkdtemp")
  433.  
  434.         try:
  435.             self.nameCheck(name, dir, pre, suf)
  436.             return name
  437.         except:
  438.             os.rmdir(name)
  439.             raise
  440.  
  441.     def test_basic(self):
  442.         # mkdtemp can create directories
  443.         os.rmdir(self.do_create())
  444.         os.rmdir(self.do_create(pre="a"))
  445.         os.rmdir(self.do_create(suf="b"))
  446.         os.rmdir(self.do_create(pre="a", suf="b"))
  447.         os.rmdir(self.do_create(pre="aa", suf=".txt"))
  448.  
  449.     def test_basic_many(self):
  450.         # mkdtemp can create many directories (stochastic)
  451.         extant = range(TEST_FILES)
  452.         try:
  453.             for i in extant:
  454.                 extant[i] = self.do_create(pre="aa")
  455.         finally:
  456.             for i in extant:
  457.                 if(isinstance(i, basestring)):
  458.                     os.rmdir(i)
  459.  
  460.     def test_choose_directory(self):
  461.         # mkdtemp can create directories in a user-selected directory
  462.         dir = tempfile.mkdtemp()
  463.         try:
  464.             os.rmdir(self.do_create(dir=dir))
  465.         finally:
  466.             os.rmdir(dir)
  467.  
  468.     def test_mode(self):
  469.         # mkdtemp creates directories with the proper mode
  470.         if not has_stat:
  471.             return            # ugh, can't use TestSkipped.
  472.  
  473.         dir = self.do_create()
  474.         try:
  475.             mode = stat.S_IMODE(os.stat(dir).st_mode)
  476.             mode &= 0777 # Mask off sticky bits inherited from /tmp
  477.             expected = 0700
  478.             if sys.platform in ('win32', 'os2emx', 'mac'):
  479.                 # There's no distinction among 'user', 'group' and 'world';
  480.                 # replicate the 'user' bits.
  481.                 user = expected >> 6
  482.                 expected = user * (1 + 8 + 64)
  483.             self.assertEqual(mode, expected)
  484.         finally:
  485.             os.rmdir(dir)
  486.  
  487. test_classes.append(test_mkdtemp)
  488.  
  489.  
  490. class test_mktemp(TC):
  491.     """Test mktemp()."""
  492.  
  493.     # For safety, all use of mktemp must occur in a private directory.
  494.     # We must also suppress the RuntimeWarning it generates.
  495.     def setUp(self):
  496.         self.dir = tempfile.mkdtemp()
  497.  
  498.     def tearDown(self):
  499.         if self.dir:
  500.             os.rmdir(self.dir)
  501.             self.dir = None
  502.  
  503.     class mktemped:
  504.         _unlink = os.unlink
  505.         _bflags = tempfile._bin_openflags
  506.  
  507.         def __init__(self, dir, pre, suf):
  508.             self.name = tempfile.mktemp(dir=dir, prefix=pre, suffix=suf)
  509.             # Create the file.  This will raise an exception if it's
  510.             # mysteriously appeared in the meanwhile.
  511.             os.close(os.open(self.name, self._bflags, 0600))
  512.  
  513.         def __del__(self):
  514.             self._unlink(self.name)
  515.  
  516.     def do_create(self, pre="", suf=""):
  517.         try:
  518.             file = self.mktemped(self.dir, pre, suf)
  519.         except:
  520.             self.failOnException("mktemp")
  521.  
  522.         self.nameCheck(file.name, self.dir, pre, suf)
  523.         return file
  524.  
  525.     def test_basic(self):
  526.         # mktemp can choose usable file names
  527.         self.do_create()
  528.         self.do_create(pre="a")
  529.         self.do_create(suf="b")
  530.         self.do_create(pre="a", suf="b")
  531.         self.do_create(pre="aa", suf=".txt")
  532.  
  533.     def test_many(self):
  534.         # mktemp can choose many usable file names (stochastic)
  535.         extant = range(TEST_FILES)
  536.         for i in extant:
  537.             extant[i] = self.do_create(pre="aa")
  538.  
  539. ##     def test_warning(self):
  540. ##         # mktemp issues a warning when used
  541. ##         warnings.filterwarnings("error",
  542. ##                                 category=RuntimeWarning,
  543. ##                                 message="mktemp")
  544. ##         self.assertRaises(RuntimeWarning,
  545. ##                           tempfile.mktemp, dir=self.dir)
  546.  
  547. test_classes.append(test_mktemp)
  548.  
  549.  
  550. # We test _TemporaryFileWrapper by testing NamedTemporaryFile.
  551.  
  552.  
  553. class test_NamedTemporaryFile(TC):
  554.     """Test NamedTemporaryFile()."""
  555.  
  556.     def do_create(self, dir=None, pre="", suf=""):
  557.         if dir is None:
  558.             dir = tempfile.gettempdir()
  559.         try:
  560.             file = tempfile.NamedTemporaryFile(dir=dir, prefix=pre, suffix=suf)
  561.         except:
  562.             self.failOnException("NamedTemporaryFile")
  563.  
  564.         self.nameCheck(file.name, dir, pre, suf)
  565.         return file
  566.  
  567.  
  568.     def test_basic(self):
  569.         # NamedTemporaryFile can create files
  570.         self.do_create()
  571.         self.do_create(pre="a")
  572.         self.do_create(suf="b")
  573.         self.do_create(pre="a", suf="b")
  574.         self.do_create(pre="aa", suf=".txt")
  575.  
  576.     def test_creates_named(self):
  577.         # NamedTemporaryFile creates files with names
  578.         f = tempfile.NamedTemporaryFile()
  579.         self.failUnless(os.path.exists(f.name),
  580.                         "NamedTemporaryFile %s does not exist" % f.name)
  581.  
  582.     def test_del_on_close(self):
  583.         # A NamedTemporaryFile is deleted when closed
  584.         dir = tempfile.mkdtemp()
  585.         try:
  586.             f = tempfile.NamedTemporaryFile(dir=dir)
  587.             f.write('blat')
  588.             f.close()
  589.             self.failIf(os.path.exists(f.name),
  590.                         "NamedTemporaryFile %s exists after close" % f.name)
  591.         finally:
  592.             os.rmdir(dir)
  593.  
  594.     def test_multiple_close(self):
  595.         # A NamedTemporaryFile can be closed many times without error
  596.  
  597.         f = tempfile.NamedTemporaryFile()
  598.         f.write('abc\n')
  599.         f.close()
  600.         try:
  601.             f.close()
  602.             f.close()
  603.         except:
  604.             self.failOnException("close")
  605.  
  606.     # How to test the mode and bufsize parameters?
  607.  
  608. test_classes.append(test_NamedTemporaryFile)
  609.  
  610.  
  611. class test_TemporaryFile(TC):
  612.     """Test TemporaryFile()."""
  613.  
  614.     def test_basic(self):
  615.         # TemporaryFile can create files
  616.         # No point in testing the name params - the file has no name.
  617.         try:
  618.             tempfile.TemporaryFile()
  619.         except:
  620.             self.failOnException("TemporaryFile")
  621.  
  622.     def test_has_no_name(self):
  623.         # TemporaryFile creates files with no names (on this system)
  624.         dir = tempfile.mkdtemp()
  625.         f = tempfile.TemporaryFile(dir=dir)
  626.         f.write('blat')
  627.  
  628.         # Sneaky: because this file has no name, it should not prevent
  629.         # us from removing the directory it was created in.
  630.         try:
  631.             os.rmdir(dir)
  632.         except:
  633.             ei = sys.exc_info()
  634.             # cleanup
  635.             f.close()
  636.             os.rmdir(dir)
  637.             self.failOnException("rmdir", ei)
  638.  
  639.     def test_multiple_close(self):
  640.         # A TemporaryFile can be closed many times without error
  641.         f = tempfile.TemporaryFile()
  642.         f.write('abc\n')
  643.         f.close()
  644.         try:
  645.             f.close()
  646.             f.close()
  647.         except:
  648.             self.failOnException("close")
  649.  
  650.     # How to test the mode and bufsize parameters?
  651.  
  652.  
  653. if tempfile.NamedTemporaryFile is not tempfile.TemporaryFile:
  654.     test_classes.append(test_TemporaryFile)
  655.  
  656. def test_main():
  657.     test_support.run_unittest(*test_classes)
  658.  
  659. if __name__ == "__main__":
  660.     test_main()
  661.